home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / editors / emacs / xemacs / xemacs-1.006 / xemacs-1 / lib / xemacs-19.13 / info / hyperbole.info-4 < prev    next >
Encoding:
GNU Info File  |  1995-09-01  |  47.7 KB  |  1,088 lines
  1. This is Info file ../info/hyperbole.info, produced by Makeinfo-1.63
  2. from the input file hyperbole.texi.
  3.  
  4. 
  5. File: hyperbole.info,  Node: Outliner Keys,  Next: Suggestion or Bug Reporting,  Prev: Smart Key Reference,  Up: Top
  6.  
  7. Outliner Keys
  8. *************
  9.  
  10.    This appendix summarizes the specialized key bindings available when
  11. editing an outline with Hyperbole.  Each key is shown together with its
  12. command binding and the documentation for that command.  Normal emacs
  13. editing keys are modified to account for the structure within outlines.
  14. An outliner command which overloads an Emacs command named *cmd* would
  15. be named *kotl-mode:cmd*.
  16.  
  17. `kfile:write  {`C-x C-w'}'
  18.      Write current outline to FILE.
  19.  
  20. `klink:create  {`C-c l'}'
  21.      Insert at point an implicit link to REFERENCE.  REFERENCE should
  22.      be a cell-ref or a list of (filename cell-ref).  See documentation
  23.      for 'kcell:ref-to-id' for valid cell-ref formats.
  24.  
  25. `kotl-mode:add-cell  {LFD}'
  26.      Add a cell following current cell at optional RELATIVE-LEVEL with
  27.      CONTENTS string.  Optional prefix arg RELATIVE-LEVEL means add as
  28.      sibling if nil or >= 0, as child if equal to universal argument,
  29.      `C-u', and as sibling of current cell's parent, otherwise.  If
  30.      added as sibling of current level, RELATIVE-LEVEL is used as a
  31.      repeat count for the number of cells to add.
  32.  
  33.      Return last newly added cell.
  34.  
  35. `kotl-mode:add-child  {`C-c a'}'
  36.      Add a new cell to current kview as first child of current cell.
  37.  
  38. `kotl-mode:add-parent  {`C-c p'}'
  39.      Add a new cell to current kview as sibling of current cell's
  40.      parent.
  41.  
  42. `kotl-mode:back-to-indentation  {`M-m'}'
  43.      Move point to the first non-read-only non-whitespace character on
  44.      this line.
  45.  
  46. `kotl-mode:backward-cell  {`C-c C-b'}'
  47.      Move to prefix ARGth prior cell (same level) within current view.
  48.      Return number of cells left to move.
  49.  
  50. `kotl-mode:backward-char  {`C-b'}'
  51.      Move point backward ARG (or 1) characters and return point.
  52.  
  53. `kotl-mode:backward-kill-word  {`M-DEL'}'
  54.      Kill up to prefix ARG words preceding point within a single cell.
  55.  
  56. `kotl-mode:backward-sentence  {`M-a'}'
  57.      Move point backward ARG (or 1) sentences and return point.
  58.  
  59. `kotl-mode:backward-word  {`M-b'}'
  60.      Move point backward ARG (or 1) words and return point.
  61.  
  62. `kotl-mode:beginning-of-buffer  {`M-<'}'
  63.      Move point to beginning of buffer and return point.
  64.  
  65. `kotl-mode:beginning-of-cell  {`C-c ,'}'
  66.      Move point to beginning of current or ARGth - 1 prior cell and
  67.      return point.
  68.  
  69. `kotl-mode:beginning-of-line  {`C-a'}'
  70.      Move point to beginning of current or ARGth - 1 line and return
  71.      point.
  72.  
  73. `kotl-mode:beginning-of-tree  {`C-c ^'}'
  74.      Move point to the level 1 root of the current cell's tree.  Leave
  75.      point at the start of the cell.
  76.  
  77. `kotl-mode:center-line  {`M-s'}'
  78.      Center the line point is on, within the width specified by
  79.      FILL-COLUMN.  This means adjusting the indentation so that it
  80.      equals the distance between the end of the text and FILL-COLUMN.
  81.  
  82. `kotl-mode:center-paragraph  {`M-S'}'
  83.      Center each nonblank line in the paragraph at or after point.  See
  84.      `center-line' for more info.
  85.  
  86. `kotl-mode:copy-after  {`C-c c'}'
  87.      Copy tree rooted at FROM-CELL-REF to follow tree rooted at
  88.      TO-CELL-REF.  If prefix arg CHILD-P is non-nil, make FROM-CELL-REF
  89.      the first child of TO-CELL-REF, otherwise make it the sibling
  90.      following TO-CELL-REF.
  91.  
  92.      Leave point at the start of the root cell of the new tree.
  93.  
  94. `kotl-mode:copy-before  {`C-c C-c'}'
  95.      Copy tree rooted at FROM-CELL-REF to precede tree rooted at
  96.      TO-CELL-REF.  If prefix arg PARENT-P is non-nil, make
  97.      FROM-CELL-REF the first child of TO-CELL-REF's parent, otherwise
  98.      make it the preceding sibling of TO-CELL-REF.
  99.  
  100.      Leave point at the start of the root cell of the new tree.
  101.  
  102. `kotl-mode:copy-to-buffer  {`C-c M-c'}'
  103.      Copy outline tree rooted at CELL-REF to a non-koutline BUFFER.
  104.      Use 0 to copy the whole outline buffer.
  105.  
  106. `kotl-mode:copy-to-register  {`C-x x'}'
  107.      Copy into REGISTER the region START to END.  With optional prefix
  108.      arg DELETE-FLAG, delete region.
  109.  
  110. `kotl-mode:delete-backward-char  {`DEL'}'
  111.      Delete up to the preceding prefix ARG characters.  Return number
  112.      of characters deleted.  Optional KILL-FLAG non-nil means save in
  113.      kill ring instead of deleting.  Does not delete across cell
  114.      boundaries.
  115.  
  116. `kotl-mode:delete-blank-lines  {`C-x C-o'}'
  117.      On blank line within a cell, delete all surrounding blank lines,
  118.      leaving just one.  On isolated blank line, delete that one.  On
  119.      nonblank line, delete all blank lines that follow it.
  120.  
  121.      If nothing but whitespace follows point until the end of a cell,
  122.      delete all whitespace at the end of the cell.
  123.  
  124. `kotl-mode:delete-char  {`C-d'}'
  125.      Delete up to prefix ARG characters following point.  Return number
  126.      of characters deleted.  Optional KILL-FLAG non-nil means save in
  127.      kill ring instead of deleting.  Does not delete across cell
  128.      boundaries.
  129.  
  130. `kotl-mode:delete-indentation  {`M-^'}'
  131.      Join this line to previous and fix up whitespace at join.  If
  132.      there is a fill prefix, delete it from the beginning of this line.
  133.      With argument, join this line to following line.
  134.  
  135. `kotl-mode:demote-tree  {`TAB'}'
  136.      Move current kotl a maximum of prefix ARG levels lower in current
  137.      view.  Each cell is refilled iff its *no-fill* attribute is nil and
  138.      KOTL-MODE:REFILL-FLAG is non-nil.  With prefix ARG = 0, cells are
  139.      demoted up to one level and kotl-mode:refill-flag is treated as
  140.      true.
  141.  
  142. `kotl-mode:down-level  {`C-c d'}'
  143.      Move down prefix ARG levels lower within current tree.
  144.  
  145. `kotl-mode:end-of-buffer  {`M->'}'
  146.      Move point to end of buffer and return point.
  147.  
  148. `kotl-mode:end-of-cell  {`C-c .'}'
  149.      Move point to end of current or ARGth - 1 succeeding cell and
  150.      return point.
  151.  
  152. `kotl-mode:end-of-line  {`C-e'}'
  153.      Move point to end of current or ARGth - 1 line and return point.
  154.  
  155. `kotl-mode:end-of-tree  {`C-c $'}'
  156.      Move point to the last cell in tree rooted at the current cell.
  157.      Leave point at the start of the cell.
  158.  
  159. `kotl-mode:exchange-cells  {`C-c e'}'
  160.      Exchange CELL-REF-1 with CELL-REF-2 in current view.  Don't move
  161.      point.
  162.  
  163. `kotl-mode:fill-cell  {`C-c M-j'}'
  164.      Fill current cell within current view if it does not have the
  165.      'no-fill attribute.  With optional JUSTIFY, justify cell as well.
  166.      IGNORE-COLLAPSED-P is used when caller has already expanded cell,
  167.      indicating it is not collapsed.
  168.  
  169. `kotl-mode:fill-paragraph  {`C-x f'}'
  170.      Fill current paragraph within cell.  With optional JUSTIFY, justify
  171.      paragraph as well.  Ignore any non-nil no-fill attribute attached
  172.      to the cell.
  173.  
  174. `kotl-mode:fill-tree  {`C-M-j'}'
  175.      Refill each cell within the tree whose root is at point.
  176.  
  177. `kotl-mode:first-sibling  {`C-c <'}'
  178.      Move point to the first sibling of the present cell.  Leave point
  179.      at the start of the cell or at its present position if it is
  180.      already within the first sibling cell.
  181.  
  182. `kotl-mode:fkey-backward-char  {`left'}'
  183.      Move point backward ARG (or 1) characters and return point.
  184.  
  185. `kotl-mode:fkey-forward-char  {`right'}'
  186.      Move point forward ARG (or 1) characters and return point.
  187.  
  188. `kotl-mode:fkey-next-line  {`down'}'
  189.      Move point to ARGth next line and return point.
  190.  
  191. `kotl-mode:fkey-previous-line  {`up'}'
  192.      Move point to ARGth previous line and return point.
  193.  
  194. `kotl-mode:forward-cell  {`C-c C-f'}'
  195.      Move to prefix ARGth following cell (same level) within current
  196.      view.  Return number of cells left to move.
  197.  
  198. `kotl-mode:forward-char  {`C-f'}'
  199.      Move point forward ARG (or 1) characters and return point.
  200.  
  201. `kotl-mode:forward-para  {`M-n'}'
  202.      Move to prefix ARGth next cell (any level) within current view.
  203.  
  204. `kotl-mode:forward-paragraph  {`M-]'}'
  205.      Move to prefix ARGth next cell (any level) within current view.
  206.  
  207. `kotl-mode:forward-sentence  {`M-e'}'
  208.      Move point forward ARG (or 1) sentences and return point.
  209.  
  210. `kotl-mode:forward-word  {`M-f'}'
  211.      Move point forward ARG (or 1) words and return point.
  212.  
  213. `kotl-mode:goto-cell  {`C-c g'}'
  214.      Move point to start of cell given by CELL-REF.  (See
  215.      'kcell:ref-to-id'.) Return point iff CELL-REF is found within
  216.      current view.  With a prefix argument, CELL-REF is assigned the
  217.      argument value for use as an idstamp.
  218.  
  219.      Optional second arg, ERROR-P, non-nil means signal an error if
  220.      CELL-REF is not found within current view.  Will signal same error
  221.      if called interactively when CELL-REF is not found.
  222.  
  223. `kotl-mode:hide-sublevels  {`C-X $'}'
  224.      Hide all cells in outline at levels deeper than LEVELS-TO-KEEP (a
  225.      number). Shows any hidden cells within LEVELS-TO-KEEP.  1 is the
  226.      first level.
  227.  
  228. `kotl-mode:hide-subtree  {`C-M-h'}'
  229.      Hide subtree, ignoring root, at optional CELL-REF (defaults to
  230.      cell at point).
  231.  
  232. `kotl-mode:hide-tree  {`C-c BS'}'
  233.      Collapse kotl rooted at optional CELL-REF (defaults to cell at
  234.      point).
  235.  
  236. `kotl-mode:insert-register  {`C-c r i'}'
  237.      Insert contents of register REGISTER at point in current cell.
  238.      REGISTER is a character naming the register to insert.  Normally
  239.      puts point before and mark after the inserted text.  If optional
  240.      second arg is non-nil, puts mark before and point after.
  241.      Interactively, second arg is non-nil if prefix arg is supplied.
  242.  
  243. `kotl-mode:just-one-space  {`M-\'}'
  244.      Delete all spaces and tabs around point and leave one space.
  245.  
  246. `kotl-mode:kcell-help  {`C-c h'}'
  247.      Display a temporary buffer with CELL-REF's properties.  CELL-REF
  248.      defaults to current cell.  Optional prefix arg CELLS-FLAG selects
  249.      the cells to print:   If = 1, print CELL-REF's cell only;   If >
  250.      1, print CELL-REF's visible kotl (the tree rooted at CELL-REF);
  251.      If < 1, print all visible cells in current view  (CELL-REF is not
  252.      used).
  253.  
  254.      See also the documentation for `kotl-mode:properties'.
  255.  
  256. `kotl-mode:kill-contents  {`C-c k'}'
  257.      Kill contents of cell from point to cell end.  With prefix ARG,
  258.      kill entire cell contents.
  259.  
  260. `kotl-mode:kill-line  {`C-k'}'
  261.      Kill ARG lines from point.
  262.  
  263. `kotl-mode:kill-region  {`C-w'}'
  264.      Kill region between START and END within a single kcell.  With
  265.      optional COPY-P equal to 't, copy region to kill ring but does not
  266.      kill it.  With COPY-P any other non-nil value, return region as a
  267.      string without affecting kill ring.
  268.  
  269.      If the buffer is read-only and COPY-P is nil, the region will not
  270.      be deleted but it will be copied to the kill ring and then an
  271.      error will be signaled.
  272.  
  273. `kotl-mode:kill-ring-save  {`M-w'}'
  274.      Copy region between START and END within a single kcell to kill
  275.      ring.
  276.  
  277. `kotl-mode:kill-sentence  {`M-k'}'
  278.      Kill up to prefix ARG (or 1) sentences following point within a
  279.      single cell.
  280.  
  281. `kotl-mode:kill-tree  {`C-c C-k'}'
  282.      Kill ARG following trees starting with tree rooted at point.  If
  283.      ARG is not a non-positive number, nothing is done.
  284.  
  285. `kotl-mode:kill-word  {`M-d'}'
  286.      Kill up to prefix ARG words following point within a single cell.
  287.  
  288. `kotl-mode:last-sibling  {`C-c >'}'
  289.      Move point to the last sibling of the present cell.  Leave point
  290.      at the start of the cell or at its present position if it is
  291.      already within the last sibling cell.
  292.  
  293. `kotl-mode:mail-tree  {`C-c @'}'
  294.      Mail outline tree rooted at CELL-REF.  Use "0" for whole outline
  295.      buffer.
  296.  
  297. `kotl-mode:move-after  {`C-c m'}'
  298.      Move tree rooted at FROM-CELL-REF to follow tree rooted at
  299.      TO-CELL-REF.  If prefix arg CHILD-P is non-nil, make FROM-CELL-REF
  300.      the first child of TO-CELL-REF, otherwise make it the sibling
  301.      following TO-CELL-REF.  With optional COPY-P, copies tree rather
  302.      than moving it.
  303.  
  304.      Leave point at original location but return the tree's new start
  305.      point.
  306.  
  307. `kotl-mode:move-before  {`C-c RET'}'
  308.      Move tree rooted at FROM-CELL-REF to precede tree rooted at
  309.      TO-CELL-REF.  If prefix arg PARENT-P is non-nil, make
  310.      FROM-CELL-REF the first child of TO-CELL-REF's parent, otherwise
  311.      make it the preceding sibling of TO-CELL-REF.  With optional
  312.      COPY-P, copies tree rather than moving it.
  313.  
  314.      Leave point at original location but return the tree's new start
  315.      point.
  316.  
  317. `kotl-mode:newline  {`RET'}'
  318.      Insert a newline.  With ARG, insert ARG newlines.  In Auto Fill
  319.      mode, if no numeric arg, break the preceding line if it is too
  320.      long.
  321.  
  322. `kotl-mode:next-cell  {`C-c C-n'}'
  323.      Move to prefix ARGth next cell (any level) within current view.
  324.  
  325. `kotl-mode:next-line  {`C-n'}'
  326.      Move point to ARGth next line and return point.
  327.  
  328. `kotl-mode:open-line  {`C-o'}'
  329.      Insert a newline and leave point before it.  With arg N, insert N
  330.      newlines.
  331.  
  332. `kotl-mode:overview  {`C-c C-o'}'
  333.      Show only the first line of each cell in the current outline.
  334.  
  335. `kotl-mode:previous-cell  {`C-c C-p'}'
  336.      Move to prefix ARGth previous cell (any level) within current view.
  337.  
  338. `kotl-mode:previous-line  {`C-p'}'
  339.      Move point to ARGth previous line and return point.
  340.  
  341. `kotl-mode:promote-tree  {`M-TAB'}'
  342.      Move current kotl a maximum of prefix ARG levels higher in current
  343.      view.  Each cell is refilled iff its *no-fill* attribute is nil and
  344.      KOTL-MODE:REFILL-FLAG is non-nil.  With prefix ARG = 0, cells are
  345.      promoted up to one level and kotl-mode:refill-flag is treated as
  346.      true.
  347.  
  348. `kotl-mode:scroll-down  {`M-v'}'
  349.      Scroll text of current window downward ARG lines; or a windowful
  350.      if no ARG.
  351.  
  352. `kotl-mode:scroll-up  {`C-v'}'
  353.      Scroll text of current window upward ARG lines; or a windowful if
  354.      no ARG.
  355.  
  356. `kotl-mode:set-fill-prefix  {`C-x l'}'
  357.      Sets fill prefix to line up to point.  With prefix arg TURN-OFF or
  358.      at begin of line, turns fill prefix off.
  359.  
  360. `kotl-mode:show-all  {`C-c C-a'}'
  361.      Show (expand) all cells in current view.
  362.  
  363. `kotl-mode:show-subtree'
  364.      Show subtree, ignoring root, at optional CELL-REF (defaults to
  365.      cell at point).
  366.  
  367. `kotl-mode:show-tree  {`C-c C-s'}'
  368.      Display fully expanded kotl rooted at CELL-REF.
  369.  
  370. `kotl-mode:split-cell  {`C-c s'}'
  371.      Split cell into two cells and move to new cell.  Cell contents
  372.      after point become part of newly created cell.  Default is to
  373.      create new cell as sibling of current cell.  With optional
  374.      universal ARG, `C-u', new cell is added as child of current cell.
  375.  
  376. `kotl-mode:top-cells  {`C-c C-t'}'
  377.      Collapse all level 1 cells in view, thereby hiding any sublevels.
  378.  
  379. `kotl-mode:transpose-cells  {`C-c t'}'
  380.      Exchange current and previous visible cells, leaving point after
  381.      both.  If no previous cell, exchange current with next cell.  With
  382.      prefix ARG, take current cell and move it past ARG cells.  With
  383.      prefix ARG = 0, interchange the cell that contains point with the
  384.      cell that contains mark.
  385.  
  386. `kotl-mode:transpose-chars  {`C-t'}'
  387.      Interchange characters around point, moving forward one character.
  388.      With prefix ARG, take character before point and drag it forward
  389.      past ARG other characters (backward if ARG negative).  If no
  390.      prefix ARG and at end of line, the previous two characters are
  391.      exchanged.
  392.  
  393. `kotl-mode:transpose-lines  {`C-x C-t'}'
  394.      Exchange current line and previous line, leaving point after both.
  395.      If no previous line, exchange current with next line.  With prefix
  396.      ARG, take previous line and move it past ARG lines.  With prefix
  397.      ARG = 0, interchange the line that contains point with the line
  398.      that contains mark.
  399.  
  400. `kotl-mode:transpose-words  {`M-t'}'
  401.      Interchange words around point, leaving point after both words.
  402.      With prefix ARG, take word before or around point and drag it
  403.      forward past ARG other words (backward if ARG negative).  If ARG
  404.      is zero, the words around or after point and around or after mark
  405.      are interchanged.
  406.  
  407. `kotl-mode:up-level  {`C-c u'}'
  408.      Move up prefix ARG levels higher in current outline view.
  409.  
  410. `kotl-mode:yank  {`C-y'}'
  411.      Reinsert the last stretch of killed text.  More precisely,
  412.      reinsert the stretch of killed text most recently killed OR
  413.      yanked.  Put point at end, and set mark at beginning.  With just
  414.      C-u as argument, same but put point at beginning (and mark at end).
  415.      With argument N, reinsert the Nth most recently killed stretch of
  416.      killed text.  See also the command M-x kotl-mode:yank-pop.
  417.  
  418. `kotl-mode:yank-pop  {`M-y'}'
  419.      Replace just-yanked stretch of killed text with a different
  420.      stretch.  This command is allowed only immediately after a `yank'
  421.      or a `yank-pop'.  At such a time, the region contains a stretch of
  422.      reinserted previously-killed text.  `yank-pop' deletes that text
  423.      and inserts in its place a different stretch of killed text.
  424.  
  425.      With no argument, the previous kill is inserted.  With argument N,
  426.      insert the Nth previous kill.  If N is negative, this is a more
  427.      recent kill.
  428.  
  429.      The sequence of kills wraps around, so that after the oldest one
  430.      comes the newest one.
  431.  
  432. `kotl-mode:zap-to-char  {`M-z'}'
  433.      Kill up to and including prefix ARG'th occurrence of CHAR.  Goes
  434.      backward if ARG is negative; error if CHAR not found.
  435.  
  436. `kview:set-label-type  {`C-c C-l'}'
  437.      Change kview's label display type to NEW-TYPE, updating all
  438.      displayed labels.  See documentation for variable,
  439.      kview:default-label-type, for valid values of NEW-TYPE.
  440.  
  441. 
  442. File: hyperbole.info,  Node: Suggestion or Bug Reporting,  Next: Questions and Answers,  Prev: Outliner Keys,  Up: Top
  443.  
  444. Suggestion or Bug Reporting
  445. ***************************
  446.  
  447.    See the `README' file in the Hyperbole distribution directory for
  448. complete details on Hyperbole mailing lists and how to subscribe.
  449.  
  450.    If you find any errors in Hyperbole's operation or documentation,
  451. feel free to report them to the Hyperbole discussion list:
  452. hyperbole@hub.ucsb.edu.  Be sure to use the Msg/Compose-Hypb-Mail menu
  453. item whenever you send a message to the mail list since it will insert
  454. important system version information for you.
  455.  
  456.    If you use Hyperbole mail or news support, *note Buttons in Mail::.,
  457. a click with your Action Key on the Hyperbole mail list address will
  458. insert a description of your Hyperbole configuration information into
  459. your outgoing message, so that you do not have to type it.  This is
  460. useful when composing a reply for the Hyperbole mail list.  Otherwise,
  461. be sure to include your Emacs, Hyperbole and window system versions in
  462. your message.  Your Hyperbole version number can be found in the
  463. top-level Hyperbole menu.
  464.  
  465.    Please use your subject line to state the position that your message
  466. takes on the topic that it addresses, e.g. send "Subject: Basic bug in
  467. top-level Hyperbole menu." rather than "Subject: Hyperbole bug".  This
  468. simple rule makes all e-mail communication much easier.
  469.  
  470.    If you have suggestions on how to improve Hyperbole, send them to the
  471. same address.  Here are some issues you might address:
  472.  
  473.    * What did you like and dislike about the system?
  474.  
  475.    * What kinds of tasks, if any, does it seem to help you with?
  476.  
  477.    * What did you think of the Emacs-based user interface?
  478.  
  479.    * How was the Hyperbole Manual and other documentation?
  480.  
  481.    * Was the setup trivial, average or hard?
  482.  
  483.    * What areas of Hyperbole would you like to see expanded/added?
  484.  
  485.    * How does it compare to other hypertext tools you have used?
  486.  
  487.    * Was it easy or difficult to create your own types?  Why?
  488.  
  489.    * Did you get any use out of the external system encapsulations?
  490.  
  491. 
  492. File: hyperbole.info,  Node: Questions and Answers,  Next: Ongoing Work,  Prev: Suggestion or Bug Reporting,  Up: Top
  493.  
  494. Questions and Answers
  495. *********************
  496.  
  497. *How can I change the Smart Mouse Key bindings?*
  498.      Since the Smart Mouse Keys are set up for use under five different
  499.      Emacs configurations, there is no easy way to provide user level
  500.      customization.  Therefore, to change the bindings you must edit the
  501.      `hmouse-setup' and `hmouse-get-bindings' functions in the
  502.      `hmouse-key.el' file.
  503.  
  504.      The HKEY-ALIST and HMOUSE-ALIST variable settings in
  505.      `hui-mouse.el' and `hui-window.el' must be altered if you want to
  506.      change what the Smart Keys do in particular contexts.  You should
  507.      then update the Smart Key summary documentation in the file,
  508.      `hypb-mouse.txt', and potentially the same summary in this manual.
  509.  
  510. *Missing Action Types*
  511.      What if someone sends a mail message with a button for which I do
  512.      not have the action type?  Or a button whose link referent I can't
  513.      access?
  514.  
  515.      You receive an error that an action type is not defined or a link
  516.      referent is not accessible/readable if you try to use the button.
  517.      This is hardly different than trying to get through a locked door
  518.      without a key; you try the doorknob, find that it is locked, and
  519.      then realize that you need to take a different approach or else
  520.      give up.
  521.  
  522.      Like all communication, people need to coordinate, which usually
  523.      requires an iterative process.  If you get a mail message with a
  524.      button for which you don't have the action type, you mail the
  525.      sender and request it.
  526.  
  527. *How can I modify a number of global buttons in succession?*
  528.      Rather than typing the name for each, it is quicker to jump to the
  529.      global button file and edit the buttons there as you would any
  530.      explicit buttons.  By default, the ButFile/PersonalFile menu item
  531.      takes you to the file where global buttons are saved.
  532.  
  533. *Why is all the button data scattered across directories?*
  534.      When you think of a hyper-space that you depend on every day, you
  535.      don't want to have a single point of failure make you incapable of
  536.      doing work.  With Hyperbole, if some directories become
  537.      unavailable for a particular time (e.g. the filesystems on which
  538.      they reside are dismounted) you can still work elsewhere with
  539.      minimal effect.  We believe this to be a compelling factor to
  540.      leave the design with external button data storage.
  541.  
  542.      This design also permits the potential addition of buttons to
  543.      read-only media.
  544.  
  545. *Why are action types defined separately from their implicit button types?*
  546.      Any category of button can make use of an action type.  Some
  547.      action types are useful as behavior definitions for a variety of
  548.      button categories, so all action types are defined separately to
  549.      give them independence from those types which apply them.
  550.  
  551.      For implicit button types that require a lot of code, it is useful
  552.      to add a module that includes the implicit button type definition,
  553.      its action type definition and supporting code.
  554.  
  555. 
  556. File: hyperbole.info,  Node: Ongoing Work,  Next: References,  Prev: Questions and Answers,  Up: Top
  557.  
  558. Ongoing Work
  559. ************
  560.  
  561. This appendix is included for a number of reasons:
  562.  
  563.    * to better allow you to assess whether to work with Hyperbole by
  564.      providing sketches of possible additions:
  565.  
  566.    * to direct further development effort towards known needs;
  567.  
  568.    * and to acknowledge known weaknesses in the current system.
  569.  
  570.      Note that due to a lack of volunteers to further develop
  571.      Hyperbole, much of this work may not be done.  So if you want to
  572.      see these features, encourage qualified people to volunteer.
  573.  
  574. Button Copying, Killing, and Yanking
  575.      There is as yet no means of transferring buttons among buffers.  We
  576.      realize this is a critical need.  Users should be able to
  577.      manipulate text with embedded buttons in ordinary ways.  Some of
  578.      the Emacs Lisp functions that must be augmented to support this
  579.      behavior include:
  580.  
  581.             (append-next-kill)
  582.             (copy-region-as-kill)
  583.             (delete-region) ;; a built-in function
  584.             (get-register)
  585.             (insert-buffer-substring)   ;; a built-in function
  586.             (insert-file-contents)
  587.             (kill-append)
  588.             (kill-region)
  589.             (rotate-yank-pointer)
  590.             (set-register)
  591.             (view-register)
  592.             (yank)
  593.             (yank-pop)
  594.             (undo)
  595.  
  596. Trails
  597.      Trails are an extension to the basic history mechanism presently
  598.      offered by Hyperbole.  Trails will allow a user to capture, edit
  599.      and store a specific sequence and set of views of information for
  600.      later replay by other users.  Conditional branching may also be
  601.      supported.
  602.  
  603. Storage of button data within button source files.
  604.      The current design choice of storing buttons external to the
  605.      source file was made under the assumption that people should be
  606.      able to look at files that contain Hyperbole buttons with any
  607.      standard editor or tool and not be bothered by the ugly button
  608.      data (since they won't be able to utilize the buttons anyway, they
  609.      don't need to see or have access to them).
  610.  
  611.      In many contexts, embedding the button data within the source
  612.      files may be a better choice, so a provision which would allow
  613.      selection of either configuration may be added.  Here are some of
  614.      the PROs and CONs of both design choices:
  615.  
  616.                      POSITIVE                        NEGATIVE
  617.           
  618.           Bdata in src file
  619.                      Documents can stand alone.      All edit operators have
  620.                      Normal file operations apply.   to account for file
  621.                                                      structure and hide
  622.                      Simplifies creation and         internal components.
  623.                      facility expansion for
  624.                      structured and multi-media
  625.                      files.
  626.           
  627.           Bdata external to src file
  628.                      Files can be displayed and      Currently, bdata for
  629.                      printed exactly as they look.   whole directory is
  630.                      No special display formatting   locked when any bdata
  631.                      is necessary.                   entry is locked.
  632.           
  633.                      Button-based searches and
  634.                      database-type lookup operations
  635.                      need only search one file
  636.                      per directory.
  637.  
  638. Forms-based Interfaces
  639.      This will allow one to create buttons more flexibly.  For example,
  640.      button attributes could be given in any order.  Entry of long code
  641.      sequences, quick note taking and cross-referencing would also be
  642.      made easier.
  643.  
  644. Collaboration Support
  645.      From the early stages of Hyperbole design, collaborative work
  646.      environments have been considered.  A simple facility has
  647.      demonstrated broadcast of button activations to a number of
  648.      workstations on a local area network, so that one user can lead
  649.      others around an information space, as during an online design
  650.      review.  (This facility is not yet ready for release.)  We shall
  651.      do some work in specific collaborative mechanisms, but also expect
  652.      that others who concentrate in collaborative work will provide
  653.      more extensive capabilities.
  654.  
  655. 
  656. File: hyperbole.info,  Node: References,  Next: Key Binding Index,  Prev: Ongoing Work,  Up: Top
  657.  
  658. References
  659. **********
  660.  
  661. [AkMcYo88]
  662.      Akscyn, R. M., D. L. McCracken and E. A. Yoder. KMS: A Distributed
  663.      Hypermedia System for Managing Knowledge in Organizations.
  664.      *Communications of the ACM*, Vol. 31, No. 7, July 1988, pp.
  665.      820-835.
  666.  
  667. [Bro87]
  668.      Brown, P. J. Turning Ideas into Products: The Guide System.
  669.      *Proceedings of Hypertext '87*, November 13-15, 1987, Chapel Hill,
  670.      NC.  ACM: NY, NY, pp. 33-40.
  671.  
  672. [Con87]
  673.      Conklin, Jeff. Hypertext: An Introduction and Survey. *IEEE
  674.      Computer*, Vol. 20, No. 9, September 1987, pp. 17-41.
  675.  
  676. [Eng68]
  677.      Engelbart, D., and W. English.  A research center for augmenting
  678.      human intellect. *Proceedings of the Fall Joint Computer
  679.      Conference*, 33, 1, AFIPS Press: Montvale, NJ, 1968, pp. 395-410.
  680.  
  681. [Eng84a]
  682.      Engelbart, D. C. Authorship Provisions in Augment.  *Proceedings
  683.      of the 1984 COMPCON Conference (COMPCON '84 Digest)*, February
  684.      27-March 1, 1984, San Francisco, CA. IEEE Computer Society Press,
  685.      Spring, 1984.  465-472. (OAD,2250,)
  686.  
  687. [Eng84b]
  688.      Engelbart, D. C. Collaboration Support Provisions in Augment.
  689.      *Proceedings of the AFIPS Office Automation Conference (OAC '84
  690.      Digest)*, February, 1984, Los Angeles, CA, 1984. 51-58. (OAD,2221,)
  691.  
  692. [Fos88]
  693.      Foss, C. L. Effective Browsing in Hypertext Systems.  *Proceedings
  694.      of the Conference on User-Oriented Content-Based Text and Image
  695.      Handling (RIAO 88)*, March 21-24, MIT, Cambridge MA. Centre de
  696.      Hautes Etudes Internationales d'Informatique Documentaire, 1988,
  697.      pp. 82-98.
  698.  
  699. [GaSmMe86]
  700.      Garrett, N., K. E. Smith and N. Meyrowitz. Intermedia: Issues,
  701.      Strategies, and Tactics in the Design of a Hypermedia Document
  702.      System.  *Computer-Supported Cooperative Work (CSCW '86)
  703.      Proceedings*, December 3-5, Austin, TX, 1986, pp. 163-174.
  704.  
  705. [HaMoTr87]
  706.      Halasz, F. G., T. P. Moran and R. H. Trigg. NoteCards in a
  707.      Nutshell. *Proceedings of the CHI and GI '87 Conference on Human
  708.      Factors in Computing Systems*, Toronto, J. M. Carroll and P. P.
  709.      Tanner, (editors), ACM: NY, NY, April 1987, pp. 45-52.
  710.  
  711. [Har88]
  712.      Harvey, G. *Understanding HyperCard.* Alameda, CA: SYBEX, Inc.,
  713.      1988.
  714.  
  715. [KaCaLoLa92]
  716.      Kaplan, S., A. M. Carroll, C. Love and D. M. LaLiberte.  *Epoch
  717.      4.0 Manual.* Department of Computer Science, University of
  718.      Illinois, Urbana-Champaign, March 1992.
  719.  
  720. [KaKaBeLaDr90]
  721.      Kaplan, S. J., M. D. Kapor, E. J. Belove, R. A.  Landsman, and T.
  722.      R. Drake.  AGENDA: A personal Information Manager.  *Communications
  723.      of the ACM*, No. 33, July 1990, pp. 105-116.
  724.  
  725. [Nel87a]
  726.      Nelson, T. H.  *Computer Lib/Dream Machines.* MicroSoft Press,
  727.      Redmond, WA, 1987.
  728.  
  729. [Nel87b]
  730.      Nelson, T. H. *Literary Machines, Edition 87.1*.  Available from
  731.      the Distributors, 702 South Michigan, South Bend, IN 46618, 1987.
  732.  
  733. [NoDr86]
  734.      Norman, D. A. and S. W. Draper, editors.  *User Centered System
  735.      Design.* Lawrence Erlbaum Associates: Hillsdale, New Jersey, 1986.
  736.  
  737. [Shn82]
  738.      Shneiderman, B. The future of interactive systems and the emergence
  739.      of direct manipulation.  *Behavior and Information Technology*,
  740.      Vol. 1, 1982, pp. 237-256.
  741.  
  742. [Sta87]
  743.      Stallman, R.  *GNU Emacs Manual.* Free Software Foundation,
  744.      Cambridge: MA, March 1987.
  745.  
  746. [Tri86]
  747.      Trigg, R., L. Suchman, and F. Halasz.  Supporting collaboration in
  748.      NoteCards.  *Proceedings of the CSCW '86 Conference*, Austin, TX,
  749.      December 1986, pp. 147-153.
  750.  
  751. [TrMoHa87]
  752.      Trigg, R. H., T. P. Moran and F. G. Halasz.  Adaptability and
  753.      Tailorability in NoteCards. *Proceedings of INTERACT '87*,
  754.      Stuttgart, West Germany, September 1987.
  755.  
  756. [Wei92]
  757.      Weiner, B.  *PIEmail: A Personalized Information Environment Mail
  758.      Tool.*  Department of Computer Science Masters Project, Brown
  759.      University: Providence, RI, May 10, 1992.
  760.  
  761. [YaHaMeDr88]
  762.      Yankelovich, N., B. J. Haan, N. Meyrowitz and S. M.  Drucker.
  763.      Intermedia: The Concept and the Construction of a Seamless
  764.      Information Environment. *IEEE Computer*, Vol. 21, No. 1, January
  765.      1988, pp.  81-96.
  766.  
  767. [YoAkMc89]
  768.      Yoder, E. A., R. M. Akscyn and D. L. McCracken.  Collaboration in
  769.      KMS, A Shared Hypermedia System. *Proceedings of the 1989 ACM
  770.      Conference on Human Factors in Computer Systems (CHI '89)*, April
  771.      30-May 4, 1989, Austin, TX, ACM: NY,NY, 1989, pp. 37-42.
  772.  
  773. 
  774. File: hyperbole.info,  Node: Key Binding Index,  Next: Code and File Index,  Prev: References,  Up: Top
  775.  
  776. Key Binding Index
  777. *****************
  778.  
  779. * Menu:
  780.  
  781. * ,:                                    Rolo Keys.
  782. * .:                                    Rolo Keys.
  783. * <:                                    Rolo Keys.
  784. * >:                                    Rolo Keys.
  785. * a:                                    Rolo Keys.
  786. * Action Key:                           Smart Keys.
  787. * Assist Key:                           Smart Keys.
  788. * b:                                    Rolo Keys.
  789. * C-c C-r:                              Renaming.
  790. * C-c C-y:                              Buttons in Mail.
  791. * C-c t:                                Smart Keys.
  792. * C-g:                                  Operating Menus.
  793. * C-h A:                                Smart Keys.
  794. * C-h h:                                Operating Menus.
  795. * C-h t:                                Top.
  796. * C-M-x:                                Creating Types.
  797. * C-t:                                  Operating Menus.
  798. * C-u M-o:                              Drags.
  799. * C-u M-RET:                            Smart Keys.
  800. * C-x C-e:                              Creating Types.
  801. * C-x m:                                Buttons in Mail.
  802. * C-x o:                                Drags.
  803. * DEL:                                  Rolo Keys.
  804. * f:                                    Rolo Keys.
  805. * h:                                    Rolo Keys.
  806. * M-o:                                  Drags.
  807. * M-RET:                                Smart Keys.
  808. * M-TAB:                                Rolo Keys.
  809. * n:                                    Rolo Keys.
  810. * p:                                    Rolo Keys.
  811. * q <1>:                                Operating Menus.
  812. * q:                                    Rolo Keys.
  813. * r:                                    Rolo Keys.
  814. * rolodex, moving to entries:           Rolo Keys.
  815. * rolodex, moving to matches:           Rolo Keys.
  816. * rolodex, quitting:                    Rolo Keys.
  817. * s:                                    Rolo Keys.
  818. * SPC:                                  Rolo Keys.
  819. * t:                                    Rolo Keys.
  820. * TAB:                                  Rolo Keys.
  821. * u:                                    Rolo Keys.
  822.  
  823. 
  824. File: hyperbole.info,  Node: Code and File Index,  Next: Concept Index,  Prev: Key Binding Index,  Up: Top
  825.  
  826. Code and File Index
  827. *******************
  828.  
  829. * Menu:
  830.  
  831. * action-key:                           Smart Keys.
  832. * action-key-default-function <1>:      Operating Menus.
  833. * action-key-default-function:          Smart Keys.
  834. * action-mouse-key:                     Smart Keys.
  835. * action:act-hook:                      Hook Variables.
  836. * actype:create:                        Action Types.
  837. * actype:delete:                        Action Types.
  838. * actypes::annot-bib:                   Action Types and Actions.
  839. * actypes::completion:                  Action Types and Actions.
  840. * actypes::eval-elisp:                  Action Types and Actions.
  841. * actypes::exec-kbd-macro:              Action Types and Actions.
  842. * actypes::exec-shell-cmd:              Action Types and Actions.
  843. * actypes::exec-window-cmd:             Action Types and Actions.
  844. * actypes::hyp-config:                  Action Types and Actions.
  845. * actypes::hyp-request:                 Action Types and Actions.
  846. * actypes::hyp-source:                  Action Types and Actions.
  847. * actypes::kbd-key:                     Action Types and Actions.
  848. * actypes::link-to-buffer-tmp:          Action Types and Actions.
  849. * actypes::link-to-directory:           Action Types and Actions.
  850. * actypes::link-to-doc:                 Action Types and Actions.
  851. * actypes::link-to-ebut:                Action Types and Actions.
  852. * actypes::link-to-elisp-doc:           Action Types and Actions.
  853. * actypes::link-to-file:                Action Types and Actions.
  854. * actypes::link-to-file-line:           Action Types and Actions.
  855. * actypes::link-to-Info-node:           Action Types and Actions.
  856. * actypes::link-to-kcell:               Action Types and Actions.
  857. * actypes::link-to-kotl:                Action Types and Actions.
  858. * actypes::link-to-mail:                Action Types and Actions.
  859. * actypes::link-to-regexp-match:        Action Types and Actions.
  860. * actypes::link-to-rfc:                 Action Types and Actions.
  861. * actypes::link-to-string-match:        Action Types and Actions.
  862. * actypes::man-show:                    Action Types and Actions.
  863. * actypes::rfc-toc:                     Action Types and Actions.
  864. * assist-key:                           Smart Keys.
  865. * assist-key-default-function:          Smart Keys.
  866. * assist-mouse-key:                     Smart Keys.
  867. * class, ebut <1>:                      Programmatic Button Creation.
  868. * class, ebut:                          Operational and Storage Formats.
  869. * class, hargs:                         Action Types.
  870. * class, hattr:                         Implicit Button Types.
  871. * class, hbdata:                        Operational and Storage Formats.
  872. * class, hbut <1>:                      Implicit Button Types.
  873. * class, hbut:                          Operational and Storage Formats.
  874. * class, htype:                         Creating Types.
  875. * defact:                               Action Types.
  876. * defib:                                Implicit Button Types.
  877. * dir, ~/.hyperb:                       Button Files.
  878. * ebut:create:                          Programmatic Button Creation.
  879. * ebut:create-hook:                     Hook Variables.
  880. * ebut:delete-hook:                     Hook Variables.
  881. * ebut:map:                             Programmatic Button Creation.
  882. * ebut:modify-hook:                     Hook Variables.
  883. * eval-defun:                           Creating Types.
  884. * eval-last-sexp:                       Creating Types.
  885. * file, .hypb:                          Explicit Buttons.
  886. * file, .~/.emacs:                      Renaming.
  887. * file, DEMO:                           Top.
  888. * file, DIR:                            Implicit Buttons and Types.
  889. * file, EXAMPLE.kotl:                   Outliner.
  890. * file, hactypes.el <1>:                Creating Types.
  891. * file, hactypes.el:                    Action Types.
  892. * file, hbut.el <1>:                    Programmatic Button Creation.
  893. * file, hbut.el:                        Action Types.
  894. * file, hgnus.el:                       Buttons in News.
  895. * file, hib-kbd.el:                     Implicit Button Types.
  896. * file, hibtypes.el <1>:                Implicit Buttons and Types.
  897. * file, hibtypes.el:                    Creating Types.
  898. * file, hmail.el:                       Buttons in Mail.
  899. * file, hmouse-key.el:                  Questions and Answers.
  900. * file, hsite.el <1>:                   Renaming.
  901. * file, hsite.el <1>:                   Smart Keys.
  902. * file, hsite.el <1>:                   Initializing.
  903. * file, hsite.el <1>:                   Buttons in News.
  904. * file, hsite.el <1>:                   Loading Hyperbole.
  905. * file, hsite.el <1>:                   Button Colors.
  906. * file, hsite.el <1>:                   Internal Viewers.
  907. * file, hsite.el:                       External Viewers.
  908. * file, hsys-*:                         Encapsulating Systems.
  909. * file, hui-ep*.el:                     Button Colors.
  910. * file, hui-window.el:                  Questions and Answers.
  911. * file, HYPB:                           Operating Menus.
  912. * file, MANIFEST:                       Implicit Buttons and Types.
  913. * file, README <1>:                     Suggestion or Bug Reporting.
  914. * file, README:                         Initializing.
  915. * file, wconfig.el:                     Window Configurations.
  916. * file, wrolo.el:                       Rolodex.
  917. * file, ~/.emacs <1>:                   Loading Hyperbole.
  918. * file, ~/.emacs <1>:                   Smart Keys.
  919. * file, ~/.emacs:                       Buttons in Mail.
  920. * fill-column:                          Outliner Keys.
  921. * fill-prefix:                          Button Label Normalization.
  922. * find-file-hooks:                      Hook Variables.
  923. * gbut:file:                            Glossary.
  924. * hbmap:dir-user:                       Button Files.
  925. * hbmap:filename:                       Button Files.
  926. * hbut:current <1>:                     Operational and Storage Formats.
  927. * hbut:current:                         Hook Variables.
  928. * hbut:fill-prefix-regexps:             Button Label Normalization.
  929. * hbut:label-to-key:                    Button Label Normalization.
  930. * hibtypes:begin-load-hook:             Hook Variables.
  931. * hibtypes:end-load-hook:               Hook Variables.
  932. * hkey-alist:                           Questions and Answers.
  933. * hkey-init:                            Smart Keys.
  934. * hkey-operate:                         Drags.
  935. * hmouse-alist:                         Questions and Answers.
  936. * hmouse-get-bindings:                  Questions and Answers.
  937. * hmouse-setup:                         Questions and Answers.
  938. * hpath:display-alist:                  Internal Viewers.
  939. * hpath:find-alist:                     External Viewers.
  940. * hpath:variables:                      Link Variable Substitution.
  941. * hproperty:but-emphasize-p:            Button Colors.
  942. * hproperty:cycle-but-color:            Button Colors.
  943. * htype:create-hook:                    Hook Variables.
  944. * htype:delete-hook:                    Hook Variables.
  945. * hui:ebut-delete-confirm-p:            Deletion.
  946. * hui:ebut-prompt-for-action:           Action Types and Actions.
  947. * hyperb:init-hook:                     Hook Variables.
  948. * ibtype:create:                        Implicit Button Types.
  949. * ibtype:delete:                        Implicit Button Types.
  950. * ibtypes::annot-bib:                   Implicit Buttons and Types.
  951. * ibtypes::completion:                  Implicit Buttons and Types.
  952. * ibtypes::debugger-source:             Implicit Buttons and Types.
  953. * ibtypes::dir-summary:                 Implicit Buttons and Types.
  954. * ibtypes::doc-id:                      Implicit Buttons and Types.
  955. * ibtypes::elisp-compiler-msg:          Implicit Buttons and Types.
  956. * ibtypes::grep-msg:                    Implicit Buttons and Types.
  957. * ibtypes::hyp-address:                 Implicit Buttons and Types.
  958. * ibtypes::hyp-source:                  Implicit Buttons and Types.
  959. * ibtypes::Info-node:                   Implicit Buttons and Types.
  960. * ibtypes::kbd-key:                     Implicit Buttons and Types.
  961. * ibtypes::klink:                       Implicit Buttons and Types.
  962. * ibtypes::mail-address:                Implicit Buttons and Types.
  963. * ibtypes::man-apropos:                 Implicit Buttons and Types.
  964. * ibtypes::patch-msg:                   Implicit Buttons and Types.
  965. * ibtypes::pathname:                    Implicit Buttons and Types.
  966. * ibtypes::rfc:                         Implicit Buttons and Types.
  967. * ibtypes::rfc-toc:                     Implicit Buttons and Types.
  968. * ibut:at-p:                            Implicit Button Types.
  969. * interactive:                          Action Types.
  970. * kfile:write:                          Outliner Keys.
  971. * kill-ring:                            Window Configurations.
  972. * klink:create:                         Outliner Keys.
  973. * kotl-mode-hook:                       Hook Variables.
  974. * kotl-mode:add-cell:                   Outliner Keys.
  975. * kotl-mode:add-child:                  Outliner Keys.
  976. * kotl-mode:add-parent:                 Outliner Keys.
  977. * kotl-mode:back-to-indentation:        Outliner Keys.
  978. * kotl-mode:backward-cell:              Outliner Keys.
  979. * kotl-mode:backward-char:              Outliner Keys.
  980. * kotl-mode:backward-kill-word:         Outliner Keys.
  981. * kotl-mode:backward-sentence:          Outliner Keys.
  982. * kotl-mode:backward-word:              Outliner Keys.
  983. * kotl-mode:beginning-of-buffer:        Outliner Keys.
  984. * kotl-mode:beginning-of-cell:          Outliner Keys.
  985. * kotl-mode:beginning-of-line:          Outliner Keys.
  986. * kotl-mode:beginning-of-tree:          Outliner Keys.
  987. * kotl-mode:center-line:                Outliner Keys.
  988. * kotl-mode:center-paragraph:           Outliner Keys.
  989. * kotl-mode:copy-after:                 Outliner Keys.
  990. * kotl-mode:copy-before:                Outliner Keys.
  991. * kotl-mode:copy-to-buffer:             Outliner Keys.
  992. * kotl-mode:copy-to-register:           Outliner Keys.
  993. * kotl-mode:delete-backward-char:       Outliner Keys.
  994. * kotl-mode:delete-blank-lines:         Outliner Keys.
  995. * kotl-mode:delete-char:                Outliner Keys.
  996. * kotl-mode:delete-indentation:         Outliner Keys.
  997. * kotl-mode:demote-tree:                Outliner Keys.
  998. * kotl-mode:down-level:                 Outliner Keys.
  999. * kotl-mode:end-of-buffer:              Outliner Keys.
  1000. * kotl-mode:end-of-cell:                Outliner Keys.
  1001. * kotl-mode:end-of-line:                Outliner Keys.
  1002. * kotl-mode:end-of-tree:                Outliner Keys.
  1003. * kotl-mode:exchange-cells:             Outliner Keys.
  1004. * kotl-mode:fill-cell:                  Outliner Keys.
  1005. * kotl-mode:fill-paragraph:             Outliner Keys.
  1006. * kotl-mode:fill-tree:                  Outliner Keys.
  1007. * kotl-mode:first-sibling:              Outliner Keys.
  1008. * kotl-mode:fkey-backward-char:         Outliner Keys.
  1009. * kotl-mode:fkey-forward-char:          Outliner Keys.
  1010. * kotl-mode:fkey-next-line:             Outliner Keys.
  1011. * kotl-mode:fkey-previous-line:         Outliner Keys.
  1012. * kotl-mode:forward-cell:               Outliner Keys.
  1013. * kotl-mode:forward-char:               Outliner Keys.
  1014. * kotl-mode:forward-para:               Outliner Keys.
  1015. * kotl-mode:forward-paragraph:          Outliner Keys.
  1016. * kotl-mode:forward-sentence:           Outliner Keys.
  1017. * kotl-mode:forward-word:               Outliner Keys.
  1018. * kotl-mode:goto-cell:                  Outliner Keys.
  1019. * kotl-mode:hide-sublevels:             Outliner Keys.
  1020. * kotl-mode:hide-subtree:               Outliner Keys.
  1021. * kotl-mode:hide-tree:                  Outliner Keys.
  1022. * kotl-mode:insert-register:            Outliner Keys.
  1023. * kotl-mode:just-one-space:             Outliner Keys.
  1024. * kotl-mode:kcell-help:                 Outliner Keys.
  1025. * kotl-mode:kill-contents:              Outliner Keys.
  1026. * kotl-mode:kill-line:                  Outliner Keys.
  1027. * kotl-mode:kill-region:                Outliner Keys.
  1028. * kotl-mode:kill-ring-save:             Outliner Keys.
  1029. * kotl-mode:kill-sentence:              Outliner Keys.
  1030. * kotl-mode:kill-tree:                  Outliner Keys.
  1031. * kotl-mode:kill-word:                  Outliner Keys.
  1032. * kotl-mode:last-sibling:               Outliner Keys.
  1033. * kotl-mode:mail-tree:                  Outliner Keys.
  1034. * kotl-mode:move-after:                 Outliner Keys.
  1035. * kotl-mode:move-before:                Outliner Keys.
  1036. * kotl-mode:newline:                    Outliner Keys.
  1037. * kotl-mode:next-cell:                  Outliner Keys.
  1038. * kotl-mode:next-line:                  Outliner Keys.
  1039. * kotl-mode:open-line:                  Outliner Keys.
  1040. * kotl-mode:overview:                   Outliner Keys.
  1041. * kotl-mode:previous-cell:              Outliner Keys.
  1042. * kotl-mode:previous-line:              Outliner Keys.
  1043. * kotl-mode:promote-tree:               Outliner Keys.
  1044. * kotl-mode:refill-flag:                Outliner Keys.
  1045. * kotl-mode:scroll-down:                Outliner Keys.
  1046. * kotl-mode:scroll-up:                  Outliner Keys.
  1047. * kotl-mode:set-fill-prefix:            Outliner Keys.
  1048. * kotl-mode:show-all:                   Outliner Keys.
  1049. * kotl-mode:show-subtree:               Outliner Keys.
  1050. * kotl-mode:show-tree:                  Outliner Keys.
  1051. * kotl-mode:split-cell:                 Outliner Keys.
  1052. * kotl-mode:top-cells:                  Outliner Keys.
  1053. * kotl-mode:transpose-cells:            Outliner Keys.
  1054. * kotl-mode:transpose-chars:            Outliner Keys.
  1055. * kotl-mode:transpose-lines:            Outliner Keys.
  1056. * kotl-mode:transpose-words:            Outliner Keys.
  1057. * kotl-mode:up-level:                   Outliner Keys.
  1058. * kotl-mode:yank:                       Outliner Keys.
  1059. * kotl-mode:yank-pop:                   Outliner Keys.
  1060. * kotl-mode:zap-to-char:                Outliner Keys.
  1061. * kview:set-label-type:                 Outliner Keys.
  1062. * mail:                                 Buttons in Mail.
  1063. * mail-yank-original:                   Buttons in Mail.
  1064. * rolo-add:                             Rolo Menu.
  1065. * rolo-display-matches:                 Rolo Menu.
  1066. * rolo-edit:                            Rolo Menu.
  1067. * rolo-email-format:                    Rolo Settings.
  1068. * rolo-entry-regexp:                    Rolo Settings.
  1069. * rolo-fgrep:                           Rolo Menu.
  1070. * rolo-file-list:                       Rolo Settings.
  1071. * rolo-grep:                            Rolo Menu.
  1072. * rolo-hdr-regexp:                      Rolo Settings.
  1073. * rolo-highlight-face:                  Rolo Settings.
  1074. * rolo-kill:                            Rolo Menu.
  1075. * rolo-kill-buffers-after-use:          Rolo Settings.
  1076. * rolo-save-buffers-after-use:          Rolo Settings.
  1077. * rolo-sort:                            Rolo Menu.
  1078. * rolo-word:                            Rolo Menu.
  1079. * rolo-yank:                            Rolo Menu.
  1080. * run-hooks:                            Glossary.
  1081. * smail:comment:                        Buttons in Mail.
  1082. * wconfig-delete-pop:                   Window Configurations.
  1083. * wconfig-ring-max:                     Window Configurations.
  1084. * wconfig-ring-save:                    Window Configurations.
  1085. * wconfig-yank-pop:                     Window Configurations.
  1086. * write-file-hooks:                     Hook Variables.
  1087.  
  1088.